// #include"string.h"
// namespace zhc
// {

//     //缺省值在函数声明的时候写，在函数定义的时候就不需要写了
//     string::string(const char* str)
//     {
//         _size = strlen(str);
//         _capacity = _size;
//         _str = new char[_capacity + 1]; //这里为什么是_capacity而不是_size
//         strcpy(_str,str);
//     }
//     string::~string()
//     {
//         delete[] _str;
//         _str = nullptr;
//         _size = 0;
//         _capacity = 0;
//     }
//     // string::string(const string& s)
//     // {
//     //    _str = new char[s._size + 1];
//     //    strcpy(_str,s._str);
//     //    _size = s._size;
//     //    _capacity = s._capacity;
//     // }

//     string::string(const string& s)
//     :_str(new char[s._size + 1])
//     , _size(s._size)
//     ,_capacity(s._capacity)
//     {
//        strcpy(_str,s._str);
//     }

//     //和拷贝构造的区别：一个是空间已经存在，一个是空间还未构建
//     string& string::operator=(const string& s)
//     {
//         if(this != &s)
//         {
//             delete[] _str;
//             _str = new char[s._size + 1];
//             strcpy(_str,s._str);
//             _size = s._size;
//             _capacity = s._capacity;
//         }
//         return *this;
//     }

//     size_t string::size()const
//     {
//         return _size;
//     }

//     size_t string::capacity()const
//     {
//         return _capacity;
//     }

//     char& string::operator[](size_t pos)
//     {
//         assert(pos < _size);
//         return _str[pos];
//     }

//     //解决const对象访问是的需求
//     const char& string::operator[](size_t pos)const 
//     {
//         assert(pos < _size);
//         return _str[pos];
//     }

//     //&：第一个处理作用域cout对象还在
//     //为了支持连续赋值


//     ostream& operator<<(ostream& out,const string& s)
//     {
//     //这里也可以不使用友元
//     //size()函数是公有的可以在类外进行访问
//     for(size_t i = 0;i < s.size();i++)
//       cout << s[i];
//        return out;
//     }

//     //你不理解const的原因是：cin >> x
//     //是读取数据存放到x中
//     istream& operator>>(istream& in, string& s)
//     {
//        while(1)
//        {
//         char ch;
//         //in >> ch;
//         ch = in.get();
//         if(ch == ' '||ch == '\n')
//         {
//             break;
//         }
//         else
//         {
//             s += ch;
//         }
//        }
//        return in;
//     }
    
//     string::iterator string::begin()
//     {
//         return _str;
//     }
//     string::iterator string::end()
//     {
//         return _str + _size;
//     }
//     void string::reserve(int n)
//     {
//         if( n > _capacity)
//         {
//            char* newstr = new char[n + 1];
//             strcpy(newstr,_str);
//             delete[] _str;
//             _str = newstr;
//             _capacity = n;
//         }
//     }
//     void string::push_back(char ch)
//     {
//         //空间满了，进行增容
//         if(_size == _capacity)
//         {
//             //如何s是一个空字符串
//             int newcapacity = _capacity == 0 ? 2 : _capacity * 2;
//             //这里千万别忘了 + 1
//             //_cpaacity 是能存多少个有效字符
//             reserve(newcapacity);
//         }
//         _str[_size] = ch;
//         _size++;

//         //重点
//         //_str[_size] = '\0';
//     }


//     void string::append(const char* str)
//     {
//         size_t len = strlen(str);
//         if(_size + len > _capacity)
//         {
//             size_t newcapacity = _size + len;
//             reserve(newcapacity);
//         }
//         // strcpy(_size + _str,str);
//         // _size += len;
//         for(int i = 0; i < len;i++)
//         {
//             _str[_size + i] = str[i]; 
//         }
//         _size += len;
//     }
//         string& string::operator+=(char ch)
//         {
//             //指针调用成员函数，成员变量 ->
//             this -> push_back(ch);
//             return *this;
//         }
//         string& string::operator+=(const char* str)
//         {
//             this ->append(str);
//             return *this;
//         }
//         string string::insert(size_t pos,char ch)
//         {
//             assert(pos < _size);
//             //考虑增容
//             if(_size == _capacity)
//             {
//                 int newcapacity = _capacity == 0 ? 2 : _capacity * 2;
//                 reserve(newcapacity);
//             }
//             //这样写是错误的
//             //因为strcpy不能处理内存重叠的情况
//             // char* tmpstr = _str + pos;
//             // _str[pos] = ch;
//             // strcpy(_str + pos + 1,tmpstr); 
//             // _size++;
//             //可以使用memmove来实现
//             int end = _size;
//             while(end >= pos)
//             {
//                 _str[end + 1] = _str[end];
//                 end--;
//             }
//             _str[pos] = ch;
//             _size++;
//              return *this;
//         }

//         string& string::insert(size_t pos,const char* str)
//         {
//             //strcpy(_str + pos,str);
//             //你不能这样直接进行拷贝，因为str中有一个'\0'
//             //strcpy会将'\0'拷贝过去然后自动停止
//             //std::string 本身不要求存储 \0，但大多数实现会在内部存储一个 \0 以便兼容 C 风格字符串。
//             int len = strlen(str);//统计字符串的长度：不包括 '\0'
//             if(_size + len > _capacity)
//             {
//                 int newcapacity = _size + len;
//                 reserve(newcapacity);//开空间
//             }
//             int end = _size;
//             while(end >= pos)
//             {
//                _str[end + len] = str[end];
//                end --;
//             }
//             strncpy(_str + pos,str,len);
//             _size += len;
//             return *this;
//         }
//         //在函数定义的时候不用写缺省值
//         //删除pos + len - 1个字符，
//     string& string::erase(size_t pos,size_t len)
//     {
//        assert(pos < _size);
//        if(len >= _size - pos)
//        {
//           _str[pos] = '\0';
//           _size = pos;
//        }else
//        {
//           size_t begin = pos + len;
//           //你要将'\0' 也挪过去
//           while(begin <= _size)
//           {
//             _str[begin - len] = _str[begin];
//              begin++;
//           }
//           _size -= len;
//        }
//        return *this;
//     }

//     size_t string::find(char ch,size_t pos)
//     {
//         for(size_t i = pos;i < _size;i++)
//         {
//             if(_str[i] == ch)
//             {
//                 return i;
//             }
//         }
//         return npos;//整形最大值
//     }
//     size_t string::find(const char* str,size_t pos)
//     {
//         //在s1中查找s2，返回第一个出现位置的指针
//         char* p = strstr(_str,str);
//         if(p == nullptr)
//         {
//             return npos;
//         }else
//         {
//             return p - _str;
//         }
//     }
    
//     bool string::operator<(const string& s)
//     {
//        int ret = strcmp(_str,s._str);
//        return ret < 0;    
//     }
//     bool string::operator==(const string& s)
//     {
//          int ret = strcmp(_str,s._str);
//          return ret == 0; 
//     }
//     bool string::operator<=(const string& s)
//     {
//         return *this < s ||*this == s;
//     }
//     bool string::operator>(const string& s)
//     {
//         return !(*this <= s);
//     }

//     bool string::operator>=(const string& s)
//     {
//         return *this > s || *this == s;
//     }
//     bool string::operator!=(const string& s)
//     {
//         return !(*this == s);
//     }
   






    



   




    

// }